package services.common;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

import org.apache.commons.lang.StringUtils;

import com.mysql.jdbc.Buffer;
import com.zhongan.scorpoin.common.ZhongAnOpenException;

import common.constants.CacheKey;
import common.constants.Constants;
import common.constants.SettingKey;
import common.enums.AuditStatus;
import common.enums.Client;
import common.enums.CompanyInfoType;
import common.enums.IsBlackCompany;
import common.enums.IsCaCertificatePass;
import common.enums.IsCompany;
import common.enums.NoticeScene;
import common.enums.UserStatus;
import common.utils.DateUtil;
import common.utils.DeleteImg;
import common.utils.Factory;
import common.utils.JPAUtil;
import common.utils.LoggerUtil;
import common.utils.PageBean;
import common.utils.ReentrantLockUtil;
import common.utils.ResultInfo;
import common.utils.StrUtil;
import common.utils.number.Arith;
import daos.common.UserDao;
import daos.common.UserEventDao;
import models.common.bean.BondUser;
import models.common.bean.CompanyFundStatistic;
import models.common.bean.CurrUser;
import models.common.bean.ShowCompanyInfo;
import models.common.bean.ShowUserInfo;
import models.common.bean.UserDetail;
import models.common.bean.UserEventLog;
import models.common.bean.UserFundInfo;
import models.common.bean.UserFundStatistic;
import models.common.bean.UserRegistration;
import models.common.entity.t_bank_card_user;
import models.common.entity.t_company_info;
import models.common.entity.t_company_info_side;
import models.common.entity.t_event_supervisor;
import models.common.entity.t_event_user;
import models.common.entity.t_user;
import models.common.entity.t_user_fund;
import models.common.entity.t_user_info;
import models.common.entity.t_event_supervisor.Event;
import play.cache.Cache;
import play.db.jpa.JPAPlugin;
import play.mvc.Http.Request;
import play.mvc.Scope.Session;
import services.base.BaseService;

public class UserService extends BaseService<t_user> {

	protected UserDao userDao = Factory.getDao(UserDao.class);
	
	protected static SupervisorService supervisorService = Factory.getService(SupervisorService.class);
	
	protected static UserInfoService userInfoService = Factory
			.getService(UserInfoService.class);

	protected static CompanyInfoService companyInfoService = Factory
			.getService(CompanyInfoService.class);

	protected static UserFundService userFundService = Factory
			.getService(UserFundService.class);

	protected static BankCardUserService bankCardUserService = Factory
			.getService(BankCardUserService.class);

	protected static CreditLevelService creditLevelService = Factory
			.getService(CreditLevelService.class);

	protected static NoticeService noticeService = Factory
			.getService(NoticeService.class);

	protected static SettingService settingService = Factory
			.getService(SettingService.class);
	
	protected static UserEventDao userEventDao = Factory.getDao(UserEventDao.class);

	/** 企业信息附表 */
	protected static CompanyInfoSideService companyInfoSideService = Factory
			.getService(CompanyInfoSideService.class);
	// 积分账户service
	protected static ScroeService scroeService = Factory
			.getService(ScroeService.class);
	protected static CompanyDatumService companyDatumService = Factory
			.getService(CompanyDatumService.class);

	protected UserService() {
		super.basedao = userDao;
	}

	// 企业认证通过的标志
	private final int COMPANY_AUTH_STATUS_OK = 1;

	/**
	 * 个人用户注册
	 * 
	 * @param name
	 *            用户名
	 * @param mobile
	 *            手机号码
	 * @param password
	 *            密码
	 * @param client
	 *            客户端
	 * @param ip
	 *            IP地址
	 * @param recommendCode
	 *            邀请码
	 * @return
	 * 
	 * @author Chenzhipeng
	 * @param registerType 
	 * @createDate 2015年12月15日
	 * 
	 */
	public ResultInfo registering(String name, String email, String mobile,
			String password, Client client, String ip, String recommendCode, int registerType) {
		JPAPlugin.closeTx(false);
		JPAPlugin.startTx(false);

		ResultInfo result = new ResultInfo();
		t_user user = new t_user(new Date(), email, name, mobile, password,
				recommendCode);
		user.login_count = 1;
		user.last_login_time = new Date();
		user.setLast_login_client(client);
		user.is_allow_login = true;
		user.last_login_ip = ip;
		user.is_company = IsCompany.IS_PERSON.code; // 个人用户0 ，企业用户1
		// 生成随机邀请码
		user.my_generate_code = InviteCode();
		// 用户名是否存在
		if (isNameExists(name)) {
			result.code = -1;
			result.msg = "用户名已注册";
			return result;
		}
		/* 保存用户注册信息 */
		boolean isSaveUser = userDao.save(user);
		if (!isSaveUser) {
			result.code = -1;
			result.msg = "用户注册信息失败";
			return result;
		}
		if(2 == registerType){
			/* 初始化用户基本信息 */
			boolean isSaveUInfo = userInfoService.addUserInfo(user.id, client,
					mobile, name, email,AuditStatus.SUCCESS_AUDIT);
			if (!isSaveUInfo) {
				result.code = -1;
				result.msg = "用户基本信息初始化失败";

				return result;
			}
		}else{
			/* 初始化用户基本信息 */
			boolean isSaveUInfo = userInfoService.addUserInfo(user.id, client,
					mobile, name, email);
			if (!isSaveUInfo) {
				result.code = -1;
				result.msg = "用户基本信息初始化失败";

				return result;
			}
		}
		

		/* 初始化用户资金信息 */
		boolean isSaveUFund = userFundService.addUserFundInfo(user.id, name);
		if (!isSaveUFund) {
			result.code = -1;
			result.msg = "用户资金信息初始化失败";

			return result;
		}
		boolean saveScroe = scroeService.saveScroe(user.id);
		if (!saveScroe) {
			result.code = -1;
			result.msg = "积分账户初始化失败";
			return result;
		}
		/* 用户资产签名更新 */
		result = userFundService.userFundSignUpdate(user.id);

		if (result.code < 1) {

			return result;
		}

		result.code = 1;
		result.msg = "用户注册成功";
		result.obj = user;

		/** 发送通知 */
		Map<String, Object> param = new HashMap<String, Object>();
		param.put("user_name", user.is_company == 0 ? user.name
				: user.company_full_name);
		noticeService.sendSysNotice(user.id, NoticeScene.REGISTER_SUCC, param);

		/** 注册成功，设置用户为登陆状态 */
		setCurrUser(user.id);
		flushUserCache(user.id);
		result.obj = user;
		JPAPlugin.closeTx(false);
		JPAPlugin.startTx(false);
		return result;
	}

	/**
	 * 企业用户注册2
	 * 
	 * @param 企业全称
	 *            、企业简称、营业执照编号、经办人姓名、经办人手机号码、经办人固定电话、 经办人邮箱、登录密码、邀请码
	 * @param client
	 *            客户端
	 * @param ip
	 *            IP地址
	 * @return
	 * 
	 * @author zhiliang.lan
	 * @param recommendCode
	 * @param string
	 * @param client
	 * @param password
	 * @param agentEmail
	 * @param agentTel
	 * @param agentMobile
	 * @param agentName
	 * @param businessLicenseCode
	 * @param shortName
	 * @param fullName
	 * @param userName
	 * @param agentEmail
	 * @param agentTel
	 * @param agentName
	 * @param businessLicenseCode
	 * @param string
	 * @param pc
	 * @param password
	 * @param shortName
	 * @param fullName
	 * @param agentMobile
	 * @param company_type_id
	 *            类型
	 * @createDate 2017年4月14日
	 * 
	 */
	public ResultInfo registeringCompany(String userName, String fullName,
			String shortName, String businessLicenseCode, String agentName,
			String agentMobile, String agentTel, String agentEmail,
			String password, Client client, String ip, String recommendCode,
			long company_type_id) {
		JPAPlugin.closeTx(false);
		JPAPlugin.startTx(false);
		ResultInfo result = new ResultInfo();
		// 1 jiaoyan
		if (checkCompany(fullName)) {
			result.code = -1;
			result.msg = "企业全称已存在";
			return result;
		}
		t_user user = new t_user(new Date(), agentEmail, userName, agentMobile,
				password, recommendCode);
		user.login_count = 1;
		user.last_login_time = new Date();
		user.setLast_login_client(client);
		user.is_allow_login = true;
		user.last_login_ip = ip;

		user.company_full_name = fullName;
		user.company_short_name = shortName;
		user.is_company = IsCompany.IS_COMPANY.code;
		user.my_used_code = recommendCode;
		// 生成随机邀请码
		user.my_generate_code = InviteCode();

		/* 保存用户注册信息 */
		boolean isSaveUser = userDao.save(user);
		if (!isSaveUser) {
			result.code = -1;
			result.msg = "用户注册信息失败";
			return result;
		}
		//生成小额金额随机数
		double samll_amount = samllAmount();
		
		if(samll_amount == 0){
			samll_amount = 0.66;
		}
		
		/* 初始化企业基本信息附表 */
		boolean isSide = companyInfoSideService.addCompanyInfo(user.id, client,
				fullName, shortName, businessLicenseCode, agentName, agentTel,
				agentEmail, agentMobile, company_type_id,samll_amount);

		if (!isSide) {
			result.code = -1;
			result.msg = "企业基本信息初始化失败";

			return result;
		}

		/* 初始化企业基本信息 */
		boolean isSaveCInfo = companyInfoService.addCompanyInfo(user.id,
				client, fullName, shortName, businessLicenseCode, agentName,
				agentTel, agentEmail, agentMobile, company_type_id,samll_amount);
		if (!isSaveCInfo) {
			result.code = -1;
			result.msg = "企业基本信息初始化失败";

			return result;
		}

		/* 初始化用户资金信息 */
		boolean isSaveCFund = userFundService
				.addUserFundInfo(user.id, fullName);
		if (!isSaveCFund) {
			result.code = -1;
			result.msg = "企业资金信息初始化失败";

			return result;
		}

		boolean saveScroe = scroeService.saveScroe(user.id);
		if (!saveScroe) {
			result.code = -1;
			result.msg = "积分账户初始化失败";
			return result;
		}

		/* 用户资产签名更新 */
		result = userFundService.userFundSignUpdate(user.id);

		if (result.code < 1) {
			return result;
		}
		// 企业认证
		/*
		 * t_company_info_side side=new t_company_info_side(); side.user_id =
		 * user.id; side.full_name = fullName; side.business_license_code =
		 * businessLicenseCode; try { result =
		 * companyDatumService.updateAuthenticate(side); } catch
		 * (ZhongAnOpenException e) { result.code = -1; result.msg = "企业认证失败！";
		 * } if(result.code < 1 ){ LoggerUtil.error(true,result.msg); return
		 * result; }
		 */

		result.code = 1;
		result.msg = "企业注册成功";
		result.obj = user;

		/** 发送通知 */
		Map<String, Object> param = new HashMap<String, Object>();
		param.put("user_name", user.is_company == 0 ? user.name
				: user.company_full_name);
		noticeService.sendSysNotice(user.id, NoticeScene.REGISTER_SUCC, param);

		/** 注册成功，设置用户为登陆状态 */
		setCurrUser(user.id);
		flushUserCache(user.id);
		result.obj = user;

		JPAPlugin.closeTx(false);
		JPAPlugin.startTx(false);
		return result;
	}

	/**
	 *
	 * @return
	 * @author xiaojun
	 *@version 2018-4-18 
	 */
	private double samllAmount() {
		double samll_amount = 0;
		Random random = new Random();
		double randomSamll = random.nextDouble();
		if(randomSamll != 0 && randomSamll != 1){
			samll_amount = randomSamll;
		}
		return samll_amount;
	}

	/**
	 * 用户登录
	 * 
	 * @param mobile
	 *            登录账户
	 * @param password
	 *            登录密码
	 * @param client
	 *            登录端(1-pc； 2-app；3 wechat)
	 * @param ip
	 *            登录IP
	 * @param securityLockTimes
	 *            密码连续错误次数时锁定用户
	 * @param securityLockTime
	 *            密码连续错误次数时锁定用户时长（分钟）
	 * @param type
	 *            0-个人用户；1-企业用户；9-放款人
	 * @return 登录用户对象
	 * 
	 * @author ChenZhipeng
	 * @createDate 2015年12月15日
	 */
	public ResultInfo logining(String mobile, String password, Client client,
			String ip, int securityLockTimes, int securityLockTime, int type) {
		ResultInfo result = new ResultInfo();
		t_user user = null;
		t_company_info_side companyInfoSide = null;

		if (type != IsCompany.IS_PERSON.code && StringUtils.isNotBlank(mobile)) {
			companyInfoSide = companyInfoSideService.findByName(mobile.trim());
		}
		if (type == IsCompany.IS_COMPANY.code
				&& companyInfoSide != null
				&& companyInfoSide.company_type_id == CompanyInfoType.LOANER_PERSON.code) {
			result.code = -2;
			result.msg = "请走票信风控系统会员企业登入通道";
			return result;
		}
		if (type == IsCompany.IS_COMPANY.code && companyInfoSide == null) {
			result.code = -1;
			result.msg = "请走个人会员登入通道";
			return result;
		}
		if (type == IsCompany.IS_PERSON.code
				&& companyInfoSide != null
				&& companyInfoSide.company_type_id == CompanyInfoType.LOANER_PERSON.code) {
			result.code = -2;
			result.msg = "请走票信风控系统会员企业登入通道";
			return result;
		}
		if (type == IsCompany.IS_PERSON.code
				&& companyInfoSide != null
				&& companyInfoSide.company_type_id != CompanyInfoType.LOANER_PERSON.code) {
			result.code = -2;
			result.msg = "请走融通系统会员企业登入通道";
			return result;
		}

		if (type == IsCompany.IS_PERSON.code) {
			user = userDao.findByColumn(
					"is_company=? and (mobile=? or name=? or email=?)", type,
					mobile.trim(), mobile.trim(), mobile.trim());
		} else if (type == IsCompany.IS_COMPANY.code
				&& companyInfoSide != null
				&& companyInfoSide.company_type_id != CompanyInfoType.LOANER_PERSON.code) {
			user = userDao.findByColumnQuery(mobile.trim(), type);
		} else if (type == CompanyInfoType.LOANER_PERSON.code
				&& companyInfoSide != null
				&& companyInfoSide.company_type_id == CompanyInfoType.LOANER_PERSON.code) {
			user = userDao.findByID(companyInfoSide.user_id);
		} else {
			result.code = -1;
			result.msg = "登陆失败，请重新登陆";
			return result;
		}
		/*if (type == IsCompany.IS_COMPANY.code
				&& companyInfoSide != null){
			if(companyInfoSide.getIs_black().code == IsBlackCompany.IS_BLACK.code){
				result.code = -1;
				result.msg = "您已被国家列入信用黑名单企业，不能登陆本平台!";

				return result;
			}
		}*/
		if (user == null) {
			result.code = -1;
			result.msg = "账号不存在！";

			return result;
		}
		if(user.status == UserStatus.LOGOUT.code){
			result.code = -1;
			result.msg = "账户已注销！";
			return result;
		}
		/* 判断账号是否被管理员锁定 */
		if (!user.is_allow_login) {
			result.code = -1;
			result.msg = "该账号被锁定请联系管理员";

			return result;
		}

		/* 判断账号是否被锁定 */
		if (user.is_password_locked) {
			if (DateUtil.getMinutesDiffFloor(user.password_locked_time,
					new Date()) < securityLockTime) {
				result.code = -1;
				result.msg = "连续错误次数超出请稍后再试";

				return result;
			} else {
				user.password_continue_fails = 0;
				user.is_password_locked = false;
				user.password_locked_time = null;
				if (!this.save(user)) {
					result.code = ResultInfo.ERROR_SQL;
					result.msg = "系统异常，请联系管理员";

					return result;
				}
			}
		}
		
		/* 输入的密码错误 */
		if (!user.password.equals(password)) {
			/* 获取当前错误登录次数 */
			int currLoginFailCount = user.password_continue_fails;
			currLoginFailCount += 1;
			if (currLoginFailCount >= securityLockTimes) {
				/* 用户达到锁定账号条件，执行账号锁定 */
				int i = userDao.updateLockStatus(user.id, securityLockTimes);
				if (i < 0) {
					result.code = ResultInfo.ERROR_SQL;
					result.msg = "系统异常，请联系管理员";

					return result;
				}

				result.code = -1;
				result.msg = "连续错误次数超出请稍后再试";

				return result;
			}

			/* 添加一次输入错误 */
			user.password_continue_fails = currLoginFailCount;
			if (!userDao.addPwdContinueFails(user.id)) {

				result.code = ResultInfo.ERROR_SQL;
				result.msg = "系统异常，请联系管理员";

				return result;
			}
			int count = securityLockTimes - currLoginFailCount;
			result.code = -1;
			result.msg = "密码不正确,还剩" + count + "次 机会";

			return result;
		}
		/* 登录成功，修改登录信息 */
		removeCurrUser(user.sessionId,user.id);
		String sessionId = Session.current().getId();
		user.login_count += 1;
		user.password_continue_fails = 0;
		user.last_login_time = new Date();
		user.setLast_login_client(client);
		user.last_login_ip = ip;
		user.sessionId = sessionId;
		if (!save(user)) {
			result.code = ResultInfo.ERROR_SQL;
			result.msg = "系统异常，请联系管理员";
			return result;
		}
		setCurrUser(user.id);
		flushUserCache(user.id);

		result.code = 1;
		result.msg = "登录成功";
		result.obj = user;

		return result;
	}
	/**
	 * 定时任务：登录错误次数清零
	 *
	 * @return
	 * @author xiaojun
	 *@version 2018-4-16
	 */
	public ResultInfo clearLoginErrorCount(){
		ResultInfo result = new ResultInfo();
		int i = userDao.updateLoginErrorCount();
		if(i < 0 ){
			result.code = -1;
			result.msg = "清除失败";
		}
		result.code = 1;
		result.msg = "清除成功";
		return result;
	}
	/**
	 * 清除cookie和缓存
	 * 
	 * @author Chenzhipeng
	 * @createDate 2015年12月25日
	 */
	public void removeCurrUser(String sessionId,Long user_id) {
		if (sessionId == null || "".equals(sessionId) || null == Cache.get(CacheKey.FRONT_ + sessionId) ) {
			return;
		}
		String userId = Cache.get(CacheKey.FRONT_ + sessionId).toString();
		if(!user_id.toString().equals(userId)){
			return;
		}
		// 清除登陆凭证
		Cache.delete(CacheKey.FRONT_ + sessionId);

		Object isSimulated = Cache.get(CacheKey.SIMULATED_ + sessionId);
		if (isSimulated != null) {
			Cache.delete(CacheKey.SIMULATED_ + sessionId);
		}

		removeUser(userId);
	}
	/**
	 * 微信登录缓存
	 * @param userId
	 *@author xiaojun
	 *@version 2018-5-15 下午5:11:29
	 */
	public void wxLogin(long userId,String openId){
		setCurrUser(userId);
		flushUserCache(userId);
		Cache.set("openId_"+userId, openId);
	}
	
	/**
	 * 设置用户登陆信息
	 * 
	 * @param userId
	 * 
	 * @author huangyunsong
	 * @createDate 2016年1月14日
	 */
	private void setCurrUser(long userId) {
		if (Session.current() == null) {

			return;
		}

		String sessionId = Session.current().getId();
		/* 设置用户凭证 */
		Cache.set(CacheKey.FRONT_ + sessionId, userId,
				Constants.CACHE_TIME_MINUS_30);

		return;
	}

	/**
	 * 刷新用户缓存信息
	 * 
	 * @param userId
	 * 
	 * @author huangyunsong
	 * @param is_company
	 *            用户类型 0 个人用户， 1企业用户
	 * @createDate 2016年1月14日
	 */
	public void flushUserCache(long userId) {
		CurrUser currUser = new CurrUser();
		t_user user = userDao.findUserByID(userId);
		if(user == null){
			return;
		}
//		t_user user = userDao.findByID(userId);
		t_user_fund userFund = userFundService.queryUserFundByUserId(userId);
		if (user.is_company == IsCompany.IS_PERSON.code) {// 个人用户
			t_user_info userInfo = userInfoService.findUserInfoByUserId(userId);

			if (userInfo == null) {
				return;
			}
			currUser.photo = userInfo.photo;
			currUser.user_info_id = userInfo.id;

			if (!StringUtils.isBlank(userInfo.email)) {
				currUser.is_email_verified = true;
			}

			/* 判断该用户是否电子签章认证 */
			if (userInfo.getCa_authentication_status().code == IsCaCertificatePass.PASS_YES.code) {
				currUser.ca_real_name = true;
			}

			/* 判断该用户是否实名认证 */
			if (userInfo.getIdentity_audit_status().code == AuditStatus.SUCCESS_AUDIT.code) {
				currUser.is_real_name = true;
			}

			/* 判断该用户是否绑定手机 */
			if (!StringUtils.isBlank(userInfo.mobile)) {
				currUser.is_mobile = true;
			}
		} else {// 企业用户
			t_company_info company = companyInfoService.findByColumn(
					" user_id=?", userId);
			if (company == null) {
				return;
			}
			// t_company_info company=companyInfoService.findByUserId(userId);
			currUser.photo = company.logo;
			currUser.company_full_name = company.full_name;
			currUser.company_info_id = company.id;
			currUser.company_short_name = company.short_name;
			currUser.company_info_type = company.company_type_id;
			// 企业认证
			if (company.company_authenticate_status == COMPANY_AUTH_STATUS_OK) {
				currUser.company_certif = true;
			}
			// 企业基本资料状态
			if (company.getBasic_info_audit_status() == AuditStatus.SUCCESS_AUDIT) {
				currUser.basic_info_audit_status = true;
			}
			/* 邮箱绑定 */
			if (company.agent_email != null
					&& company.agent_email.trim().length() > 0) {
				currUser.is_email_verified = true;
			}

			/* 企业实名认证 */
			if (company.getBasic_info_audit_status().code == AuditStatus.SUCCESS_AUDIT.code) {
				currUser.is_real_name = true;
			}

			/* 企业电子签章认证 */
			if (company.getCa_authentication_status().code == IsCaCertificatePass.PASS_YES.code) {
				currUser.ca_real_name = true;
			}
			/** 黑名单企业 */
			if (company.getIs_black().code == IsBlackCompany.NOT_BLACK.code || company.getIs_black().code == IsBlackCompany.IS_REDDISH.code) {
				currUser.is_black = true;
			}
			/** 小额金额鉴定 */
			if (company.getAuthenticate_status().code == AuditStatus.SUCCESS_AUDIT.code) {
				currUser.assess_status = true;
			}
			if (!StringUtils.isBlank(company.agent_mobile)) {
				currUser.is_mobile = true;
			}
			if (company.company_type_id == CompanyInfoType.THIRD_PARTY_COMPANY.code
					|| user.is_pledge_management == 1) {
				currUser.is_pledge_management = true;
			}
			if (company.company_type_id == CompanyInfoType.EARNINGS_ACCOUNT.code) {
				currUser.is_earnings_account = true;
			}
		}
		currUser.name = user.name;
		currUser.id = userId;
		currUser.payment_account = userFund.payment_account;
		currUser.is_company = user.is_company;

		/* 判断该用户是否绑定银行卡 */
		List<t_bank_card_user> cardList = bankCardUserService
				.queryCardByUserId(userId);
		if (cardList != null && cardList.size() > 0) {
			currUser.is_bank_card = true;
		}
		/* 获取该用户交易信用积分信息 */
		// t_credit_level level =
		// creditLevelService.queryLevelByCreditScore(userInfo.credit_score);
		// currUser.credit_level = level.name;
		// currUser.credit_level_picture = level.image_url;

		/* 刷新用户缓存信息 */
		Cache.set(CacheKey.USER_ + userId, currUser,
				Constants.CACHE_TIME_MINUS_30);

		return;
	}

	/**
	 * 退出时清除cookie和缓存
	 * 
	 * @author Chenzhipeng
	 * @createDate 2015年12月25日
	 */
	public void removeCurrUser() {
		if (Session.current() == null) {

			return;
		}

		String sessionId = Session.current().getId();

		String userId = Cache.get(CacheKey.FRONT_ + sessionId).toString();

		// 清除登陆凭证
		Cache.delete(CacheKey.FRONT_ + sessionId);

		Object isSimulated = Cache.get(CacheKey.SIMULATED_ + sessionId);
		if (isSimulated != null) {
			Cache.delete(CacheKey.SIMULATED_ + sessionId);
		}

		removeUser(userId);
	}

	/**
	 * 清除用户缓存
	 * 
	 * @author huangyunsong
	 * @createDate 2016年3月3日
	 */
	public void removeUser(String userId) {
		// 清除用户缓存信息
		// Cache.delete(CacheKey.USER_ + userId);

		ReentrantLockUtil.cleanCacheLock(CacheKey.USER_FUND_LOCK_ + userId);
	}

	/**
	 * 判断一个手机号是否已经存在，存在则返回true，不存在返回false
	 * 
	 * @param mobile
	 *            手机号码
	 * @return 返回Boolean值，存在返回true，不存在false
	 * 
	 * @author Chenzhipeng
	 * @createDate 2015年12月16日
	 */
	public boolean isMobileExists(String mobile) {
		t_user user = userDao.findByColumn("mobile=? ", mobile.trim());
		if (user != null) {
			return true;
		}
		return false;
	}
	
	/**
	 * 判断一个手机号是否已经存在，存在则返回true，不存在返回false
	 * 
	 * @param mobile
	 *            手机号码
	 * @param is_company
	 *            是否企业用户 0个人 1企业
	 * @return 返回Boolean值，存在返回true，不存在false
	 * 
	 * @author Chenzhipeng
	 * @createDate 2015年12月16日
	 */
	public boolean isMobileExists(String mobile, int is_company) {
		t_user user = userDao.findByColumn("mobile=? AND is_company = ?", mobile.trim(),is_company);
		if (user != null) {
			return true;
		}
		return false;
	}

	/**
	 * 判断邮箱是否存在，存在则返回true，不存在返回false
	 * 
	 * @param email
	 * @param is_company
	 * @return
	 * @author zhiliang.lan
	 * @createDate 2017年5月18日
	 */
	public boolean isEmailExists(String email) {
		t_user user = userDao.findByColumn("lower(email)=lower(?)", email);
		if (user != null) {
			return true;
		}
		return false;
	}

	/**
	 * 判断一个用户名是否已经存在，存在则返回true，不存在返回false
	 * 
	 * @param name
	 *            手机号码
	 * @return 返回Boolean值，存在返回true，不存在false
	 * 
	 * @author Chenzhipeng
	 * @createDate 2015年12月16日
	 */
	public boolean isNameExists(String name) {
		t_user user = userDao.findByColumn("lower(name)=lower(?)", name);
		if (user != null) {
			return true;
		}

		return false;
	}

	/**
	 * 通过手机号码找回用户信息
	 * 
	 * @param mobile
	 *            手机号码
	 * @return
	 * 
	 * @author Chenzhipeng
	 * @createDate 2015年12月17日
	 */
	public ResultInfo findUserInfoByMobile(String mobile,int is_company) {

		ResultInfo result = new ResultInfo();

		/* 判断手机号码是否注册 */
		if (!isMobileExists(mobile,is_company)) {
			result.code = -1;
			result.msg = "手机号码未注册";

			return result;
		}

		t_user user = userDao.findByColumn("mobile=? AND is_company = ?", mobile,is_company);
		result.obj = user;

		return result;
	}

	/**
	 * 查询注册表用户实体信息 通过userId查询
	 * 
	 * @param id
	 *            用户id
	 * @return
	 * 
	 * @author liudong
	 * @createDate 2015年12月17日
	 */
	public t_user findUserById(long id) {

		return userDao.findByID(id);
	}

	/**
	 * 查询注册表用户实体信息 根据用户的userId 用户类型isCompany 0：个人 1：企业查询用户信息
	 * 
	 * @param id
	 * @param isCompany
	 * @return t_user
	 * @author liaijun
	 * @createDate 2017年4月17日
	 * 
	 */
	public t_user findUserByIdAndType(long id, int isCompany) {
		return userDao.findUserByIdAndType(id, isCompany);
		// return userDao.findByColumn(" id =? and is_company=? ",id,isCompany);
	}

	/**
	 * 获取用户信用情况
	 * 
	 * @param userId
	 * @return
	 * 
	 * @author Chenzhipeng
	 * @createDate 2016年1月6日
	 * 
	 */
	public UserDetail findCreditSituation(long userId) {

		return userDao.findCreditSituation(userId);
	}

	/**
	 * 获取ShowUserInfo统计的字段
	 * 
	 * @param userId
	 * @param showType
	 *            用户类型
	 * @return
	 * 
	 * @author Chenzhipeng
	 * @createDate 2016年1月7日
	 * 
	 */
	public UserFundStatistic findUserFundStatistic(long userId, int showType,
			String userName) {

		return userDao.findUserFundStatistic(userId, showType, userName);
	}

	/**
	 * 获取ShowCompanyInfo统计的字段
	 * 
	 * @param userId
	 * @param showType
	 *            用户类型
	 * @return
	 * 
	 * @author zhiliang.lan
	 * @createDate 2017年4月19日
	 * 
	 */
	public CompanyFundStatistic findCompanyFundStatistic(int showType,
			String name, String fullName, String shortName, String mobile) {

		return userDao.findCompanyFundStatistic(showType, name, fullName,
				shortName, mobile);
	}

	/**
	 * 用户顶部资产信息
	 * 
	 * @param userId
	 * @return
	 * 
	 * @author Chenzhipeng
	 * @createDate 2016年1月20日
	 * 
	 */
	public UserFundInfo findUserFundInfo(long userId) {
		UserFundInfo userFundInfo = new UserFundInfo();

		return userFundInfo;
	}

	/**
	 * 融通人企业顶部资产信息
	 * 
	 * @param userId
	 * @return
	 * 
	 * @author zhiliang.lan
	 * @createDate 2017年5月15日
	 * 
	 */
	public UserFundInfo findCompanyFundInfo(long userId) {

		UserFundInfo userFundInfo = new UserFundInfo();
		t_user_fund user_fund = userFundService.queryUserFundByUserId(userId);
		// 冻结金额
		userFundInfo.freeze = user_fund.freeze;
		//可用余额
		userFundInfo.balance = user_fund.balance;
		//授信总额度
		userFundInfo.credit_limit_total = userDao.findCreditLimitTotal(userId);
		Map<String, Object> map = userDao.findRepaymentCorpus(userId);
		// 投融通总金额
		userFundInfo.amount = Double.valueOf(map.get("amount").toString());
		// 总利息
		userFundInfo.interest_all = Double.valueOf(map.get("interest").toString());
		// 查询已还本金 利息
		map = userDao.findBillAmount(userId);
		// 待还金额
		userFundInfo.repayment_corpus = Arith.sub(userFundInfo.amount,
				Double.valueOf(map.get("repayment_corpus").toString()));
		//已还金额
		userFundInfo.repayment_corpus_pay=Double.valueOf(map.get("repayment_corpus").toString());
		// 待还利息
		userFundInfo.repayment_interest = Arith.sub(userFundInfo.interest_all,
				Double.valueOf(map.get("repayment_interest").toString()));
		// 已还利息
		userFundInfo.interest = Double.valueOf(map.get("repayment_interest")
				.toString());
		// 保证金
		map = userDao.findBondAmount(userId);
		//已提交保证金
		userFundInfo.have_submit_bond = Double.valueOf(map.get(
				"have_send_money").toString());
		//已退回保证金
		userFundInfo.out_money = Double
				.valueOf(map.get("out_money").toString());
		return userFundInfo;
	}

	/**
	 * 放款人企业顶部资产信息
	 * 
	 * @param userId
	 * @return
	 * 
	 * @author zhiliang.lan
	 * @createDate 2017年5月15日
	 * 
	 */
	public UserFundInfo findLenderFundInfo(long userId) {

		UserFundInfo userFundInfo = new UserFundInfo();
		t_user_fund user_fund = userFundService.queryUserFundByUserId(userId);
		//可用余额
		userFundInfo.balance = user_fund.balance;
		// 冻结金额
		userFundInfo.freeze = user_fund.freeze;
		//授信总额度
		userFundInfo.credit_limit_total = userDao
				.findLenderCreditLimitTotal(userId);
		Map<String, Object> map = userDao.findLenderRepaymentCorpus(userId);
		// 投融通总金额
		userFundInfo.amount = Double.valueOf(map.get("amount").toString());
		// 总利息
		userFundInfo.interest_all = Double.valueOf(map.get("interest").toString());
		// 查询已还本金 利息
		map = userDao.findLenderBillAmount(userId);
		// 待还金额
		userFundInfo.repayment_corpus = Arith.sub(userFundInfo.amount,
				Double.valueOf(map.get("repayment_corpus").toString()));
		//已还金额
		userFundInfo.repayment_corpus_pay=Double.valueOf(map.get("repayment_corpus").toString());
		// 待还利息
		userFundInfo.repayment_interest = Arith.sub(userFundInfo.interest_all,
				Double.valueOf(map.get("repayment_interest").toString()));
		// 已还利息
		userFundInfo.interest = Double.valueOf(map.get("repayment_interest")
				.toString());
		// 保证金
		map = userDao.findLenderBondAmount(userId);
		//已提交保证金
		userFundInfo.have_submit_bond = Double.valueOf(map.get(
				"have_send_money").toString());
		//已退回保证金
		userFundInfo.out_money = Double
				.valueOf(map.get("out_money").toString());
		return userFundInfo;
	}

	/**
	 * 查询相应时间注册会员数目的数据
	 * 
	 * @param startTime
	 * @param endTime
	 * @param type
	 * @return
	 * 
	 * @author Chenzhipeng
	 * @createDate 2016年1月23日
	 * 
	 */
	public int findUserCount(String startTime, String endTime, int type,
			int is_company) {

		return userDao.findUserCount(startTime, endTime, type, is_company);
	}

	/****
	 * 查询用户原始密码
	 * 
	 * @param userId
	 * @return
	 * @description
	 * 
	 * @author luzhiwei
	 * @createDate 2016-5-17
	 */
	public String findUserOldPassWord(long userId) {

		return userDao.findUserOldPassWord(userId);
	}

	/**
	 * 统计用户数
	 * 
	 * @return
	 * 
	 * @author Chenzhipeng
	 * @createDate 2016年1月8日
	 * 
	 */
	public int queryTotalRegisterUserCount() {

		return userDao.findCountOfUsers();
	}

	/**
	 * 后台发标，获取关联用户
	 * 
	 * @param key
	 * @return
	 * 
	 * @author yaoyi
	 * @createDate 2016年1月9日
	 */
	public PageBean<Map<String, Object>> queryCreateBidRefUser(int currPage,
			int pageSize, String key) {

		return userDao.queryCreateBidRefUser(currPage, pageSize, key);
	}

	/**
	 * 通过手机号码获取用户ID
	 * 
	 * @param mobile
	 * @return
	 * 
	 * @author Chenzhipeng
	 * @param type 个人 0   企业  1
	 * @createDate 2015年12月18日
	 */
	public long queryIdByMobile(String mobile, int type) {

		return userDao.findIdByMobile(mobile,type);
	}

	/**
	 * 统计（个人）用户数
	 * 
	 * @param showType
	 *            筛选类型 0-所有;1-融通会员;2-投资会员;3-新用户;4-复合会员;5-正常会员;6-锁定
	 * @param currPage
	 * @param pageSize
	 * @param exports
	 *            1:导出 default：不导出
	 * @return
	 * 
	 * @author Chenzhipeng
	 * @createDate 2016年1月8日
	 * 
	 */
	public PageBean<ShowUserInfo> pageOfUserInfo(int showType, int currPage,
			int pageSize, int orderType, int orderValue, int exports,
			String userName, String userMobile, String userEmail) {

		return userDao.pageOfUserInfo(showType, currPage, pageSize, orderType,
				orderValue, exports, userName, userMobile, userEmail);
	}

	/**
	 * 后台发标，获取关联用户
	 * 
	 * @param key
	 * @param id
	 *            用户userId
	 * @return
	 * 
	 * @author yaoyi
	 * @createDate 2016年1月9日
	 */
	public ResultInfo updatePassword(long id, String password) {
		ResultInfo result = new ResultInfo();
		int i = userDao.updatePassowordById(id, password);
		if (i < 0) {
			result.code = -1;
			result.msg = "密码修改失败";

			return result;
		}

		t_user user = userDao.findByID(id);

		/** 发送通知 */
		Map<String, Object> param = new HashMap<String, Object>();
		param.put("user_name", user.is_company == 0 ? user.name
				: user.company_full_name);
		noticeService.sendSysNotice(id, NoticeScene.RESET_PASSWORD_SUCC, param);

		result.code = 1;
		result.msg = "密码修改成功";

		return result;
	}

	/**
	 * 修改用户手机号码
	 * 
	 * @param id
	 *            用户user_id
	 * @param mobile
	 *            手机号码
	 * @return
	 * 
	 * @author Chenzhipeng
	 * @createDate 2015年12月22日
	 */
	/*public ResultInfo updateUserMobile(long id, String mobile) {
		ResultInfo result = new ResultInfo();

		 判断手机号码是否存在 
		if (isMobileExistsExceptSelf(mobile, id)) {
			result.code = -1;
			result.msg = "手机号码已存在";
			return result;
		}
		 修改用户信息表中的手机号字段 
		result = userInfoService.updateUserMobile(id, mobile);
		if (result.code < 0) {

			return result;
		}
		 修改用户表中的手机号字段 
		int i = userDao.updateUserMobile(id, mobile);
		if (i < 0) {
			result.code = -1;
			result.msg = "手机号码修改失败";
			return result;
		}

		t_user user = userDao.findByID(id);

		*//** 手机号绑定更改 发送通知 *//*
		Map<String, Object> param = new HashMap<String, Object>();
		param.put("user_name", user.is_company == 0 ? user.name
				: user.company_full_name);
		noticeService.sendSysNotice(id, NoticeScene.BIND_MOBILE_SUCC, param);

		result.code = 1;
		result.msg = "手机号码修改成功";
		 刷新缓存用户信息 
		flushUserCache(id);

		return result;
	}*/

	/**
	 * 后台会员修改手机号
	 * 
	 * @param id
	 * @param mobile
	 *            手机
	 * @param is_company
	 *            0 个人用户 1 企业用户
	 * @return
	 * @author binghui.zhou
	 * @createDate 2017年7月27日
	 */
	public ResultInfo updateUserMobile(long id, String mobile, int is_company) {
		ResultInfo result = new ResultInfo();

		/* 判断手机号码是否存在 */
		if (isMobileExistsExceptSelf(mobile, id,is_company)) {
			result.code = -1;
			result.msg = "手机号码已存在";
			return result;
		}
		if (is_company == 0) {
			/* 修改用户信息表中的手机号字段 */
			result = userInfoService.updateUserMobile(id, mobile);
			if (result.code < 0) {

				return result;
			}
		} else {
			/* 修改用户信息表中的手机号字段 */
			result = companyInfoService.updateUserMobile(id, mobile);
			if (result.code < 0) {
				return result;
			}
			result = companyInfoSideService.updateUserMobile(id, mobile);
			if (result.code < 0) {
				return result;
			}
		}

		/* 修改用户表中的手机号字段 */
		int i = userDao.updateUserMobile(id, mobile);
		if (i < 0) {
			result.code = -1;
			result.msg = "手机号码修改失败";
			return result;
		}

		t_user user = userDao.findByID(id);

		/** 手机号绑定更改 发送通知 */
		Map<String, Object> param = new HashMap<String, Object>();
		param.put("user_name", user.is_company == 0 ? user.name
				: user.company_full_name);
		noticeService.sendSysNotice(id, NoticeScene.BIND_MOBILE_SUCC, param);

		result.code = 1;
		result.msg = "手机号码修改成功";
		/* 刷新缓存用户信息 */
		flushUserCache(id);

		return result;
	}

	/**
	 * 后台管理员锁定、解锁用户
	 * 
	 * @param userId
	 * @return
	 * 
	 * @author Chenzhipeng
	 * @createDate 2015年12月24日
	 */
	public ResultInfo updateIsAllowLogin(long userId) {
		ResultInfo result = new ResultInfo();
		int i = userDao.updateUserIsAllowLogin(userId);
		if (i < 0) {
			result.code = -1;
			result.msg = "修改用户锁定状态失败";

			return result;
		}
		result.code = 1;
		result.msg = "修改用户锁定状态成功";

		return result;
	}

	/**
	 * 修改用户头像
	 * 
	 * @param userId
	 *            用户Id
	 * @param photo
	 *            头像
	 * @return
	 * 
	 * @author Chenzhipeng
	 * @createDate 2015年12月25日
	 */
	public ResultInfo updateUserPhoto(long userId, String photo) {
		ResultInfo result = new ResultInfo();
		if (StringUtils.isBlank(photo)) {
			result.code = -1;
			result.msg = "头像路径为空";
			LoggerUtil.error(true, "修改头像失败");
			return result;
		}
		t_user_info user_info = userInfoService.findByColumn(" user_id = ?",
				userId);
		int i = userDao.updateUserPhoto(userId, photo);
		if (i < 0) {
			result.code = -1;
			result.msg = "头像修改失败";
			LoggerUtil.error(true, "修改头像失败");
			return result;
		}
		if (user_info != null && user_info.photo != null) {
			DeleteImg.deleteImg(user_info.photo);
		}
		result.code = 1;
		result.msg = "头像修改成功";

		return result;
	}

	/**
	 * 企业logo（副表）
	 * 
	 * @param userId
	 *            用户Id
	 * @param logo
	 * @return
	 * 
	 * @author zhiliang.lan
	 * @createDate 2017年6月16日
	 */
	public ResultInfo updateCompanySideLogo(long userId, String logo) {
		ResultInfo result = new ResultInfo();
		if (StringUtils.isBlank(logo)) {
			result.code = -1;
			result.msg = "logo路径为空";
			LoggerUtil.error(true, "修改logo失败");
			return result;
		}

		int i = userDao.updateCompanySideLogo(userId, logo);
		if (i < 0) {
			result.code = -1;
			result.msg = "logo修改失败";
			LoggerUtil.error(true, "修改logo失败");
			return result;
		}
		result.code = 1;
		result.msg = "logo修改成功";

		return result;
	}

	/**
	 * 企业logo(主表)
	 * 
	 * @param userId
	 *            用户Id
	 * @param logo
	 * @return
	 * 
	 * @author zhiliang.lan
	 * @createDate 2017年6月16日
	 */
	public ResultInfo updateCompanyLogo(long userId, String logo) {
		ResultInfo result = new ResultInfo();
		if (StringUtils.isBlank(logo)) {
			result.code = -1;
			result.msg = "logo路径为空";
			LoggerUtil.error(true, "修改logo失败");
			return result;
		}
		t_company_info company_info_side = companyInfoService
				.findCompanyInfoByUserId(userId);
		int i = userDao.updateCompanyLogo(userId, logo);
		if (i < 0) {
			result.code = -1;
			result.msg = "logo修改失败";
			LoggerUtil.error(true, "修改logo失败");
			return result;
		}

		if (null != company_info_side
				&& (company_info_side.logo != null || !""
						.equals(company_info_side.logo))) {

			boolean delete = DeleteImg.deleteImg(company_info_side.logo);
		}

		result.code = 1;
		result.msg = "logo修改成功";

		return result;
	}

	/**
	 * 修改会员退出信息
	 * 
	 * @param userId
	 *            用户id
	 * @param client
	 *            上次登录入口
	 * @param ip
	 * @return
	 * 
	 * @author Chenzhipeng
	 * @createDate 2015年12月28日
	 * 
	 */
	public ResultInfo updateUserLoginOutInfo(long userId, int client, String ip) {
		ResultInfo result = new ResultInfo();
		int i = userDao.updateUserLastLoginInfo(userId, client, ip);
		if (i < 0) {
			result.code = -1;
			result.msg = "修改用户登出信息失败";

			return result;
		}
		/* 清除缓存 */
		removeCurrUser();

		result.code = 1;
		result.msg = "修改用户登出信息成功";

		return result;
	}

	/**
	 * 随机生成两个英文字母,并与手机号码连接,获得用户名
	 * 
	 * @description
	 * 
	 * @param mobile
	 *            手机号码
	 * @return
	 * 
	 * @author Chenzhipeng
	 * @createDate 2015年12月16日
	 */
	public String userNameFactory(String mobile) {
		Random random = new Random();
		StringBuffer word = new StringBuffer();
		for (int i = 0; i < 2; i++) {
			/* 取得大写或小写 */
			int choice = random.nextInt(2) % 2 == 0 ? 65 : 97;
			word.append((char) (choice + random.nextInt(26)));
		}

		/* 获取系统设置的否定词 */
		String sensitiveWords = settingService
				.findSettingValueByKey(SettingKey.SENSITIVE_WORDS);
		if (!StringUtils.isBlank(sensitiveWords)) {
			if (sensitiveWords.contains(word)) {
				userNameFactory(mobile);
			}
		}

		word.append(mobile);

		return word.toString();
	}

	/**
	 * 统计（企业）用户数
	 * 
	 * @param showType
	 *            筛选类型 0-所有;1-融通会员;2-投资会员;3-新用户;4-复合会员;5-正常会员;6-锁定
	 * @param companyTypeId
	 *            企业用户类型3-担保人 8-债权债务人 9-放款人
	 * @param currPage
	 * @param pageSize
	 * @param exports
	 *            1:导出 default：不导出
	 * @param name
	 *            用户名
	 * @param mobile
	 *            电话
	 * @param shortName
	 *            简称
	 * @param fullName
	 *            全称
	 * @return
	 * @author zhiliang.lan
	 * 
	 * @createDate 2017年4月17日
	 * 
	 */
	public PageBean<ShowCompanyInfo> pageOfCompanyInfo(int showType,
			long companyTypeId, int orderType, int orderValue, int currPage,
			int pageSize, String name, String fullName, String shortName,
			String mobile, int exports) {

		return userDao.pageOfCompanyInfo(showType, companyTypeId, orderType,
				orderValue, currPage, pageSize, name, fullName, shortName,
				mobile, exports);
	}

	/**
	 * 会员审核的查询列表 service
	 * 
	 * @param currPage
	 * @param pageSize
	 * @param userName
	 * @return
	 * @author zhiliang.lan
	 * @createDate 2017年4月20日
	 */
	public PageBean<ShowUserInfo> pageOfAuditUserInfo(int showType,
			int currPage, int pageSize, String userName) {

		return userDao.pageOfAuditUserInfo(showType, currPage, pageSize,
				userName);
	}

	/**
	 * 企业审核的查询列表 service
	 * 
	 * @param currPage
	 * @param pageSize
	 * @param userName
	 * @return
	 * @author zhiliang.lan
	 * @param companyTypeId
	 * @createDate 2017年4月21日
	 */
	public PageBean<ShowCompanyInfo> pageOfAuditCompanyInfo(int orderType,int orderValue,int showType,
			int currPage, int pageSize, String userName, Long companyTypeId,
			int exports) {

		return userDao.pageOfAuditCompanyInfo(orderType,orderValue,showType, currPage, pageSize,
				userName, companyTypeId, exports);
	}

	/**
	 * 根据企业名称查找数据
	 * 
	 * @param userName
	 *            企业全称/企业简称
	 * @return
	 * @author binghui.zhou
	 * @param is_company
	 * @createDate 2017年5月8日
	 */
	public boolean company(String userName) {
		t_user user = userDao.findByColumnName(userName);
		if (user != null) {
			return true;
		}

		return false;
	}

	/**
	 * 根据邮箱查找对应的用户信息判断邮箱是否注册
	 * 
	 * @param userName
	 *            邮箱号
	 * @return
	 * @author binghui.zhou
	 * @param is_company
	 * @createDate 2017年5月8日
	 */
	public boolean isEmail(String userName) {
		t_user user = this.userDao.findByColumn("email=?", userName.trim());
		if (user != null) {
			return true;
		}
		return false;
	}

	/**
	 * 根据企业全称查找用户信息
	 * 
	 * @param company_full_name
	 *            企业全称
	 * @return
	 * @author binghui.zhou createDate 2017年5月9日
	 */
	public boolean checkCompany(String company_full_name) {
		t_user user = this.userDao.findByColumn("company_full_name=?",
				company_full_name.trim());
		if (user != null) {
			return true;
		}
		return false;
	}

	/**
	 * 根据邮箱查找用户的ID
	 * 
	 * @param email邮箱
	 * @param is_company
	 *            0企业用户 1个人用户
	 * @return
	 */
	public long queryIdByEmail(String email) {
		return userDao.queryIdByEmail(email);
	}

	/**
	 * 获取商票缴纳保证金的用户
	 * 
	 * @param id
	 *            商票额度id
	 * @return BondUser 用户信息
	 * @author liaijun
	 * @createDate 2017年5月10日
	 */
	public BondUser findUserByCretorId(long id) {

		return userDao.findUserByCretorId(id);
	}

	/**
	 * 判断一个邀请码是否已经存在，存在则返回true，不存在返回false，不管是否个人或者企业邀请码
	 * 
	 * @return
	 * @author zhiliang.lan
	 * @createDate 2017年5月23日
	 */
	public boolean isInviteCodeExist(String inviteCode) {

		t_user user = userDao.findByColumn("lower(my_generate_code)=lower(?) ",
				inviteCode.trim());
		if (user != null) {
			return true;
		}
		return false;
	}

	/**
	 * 判断一个邀请码是否已经存在，存在则返回true，不存在返回false，只判断是否为企业邀请码是否存在
	 * 
	 * @return
	 * @author zhiliang.lan
	 * @createDate 2017年6月21日16:54:54
	 * @param isCompany
	 *            是否企业参数
	 */
	public boolean isCompanyInviteCodeExist(String inviteCode, int isCompany) {

		t_user user = userDao.findByColumn(
				"lower(my_generate_code)=lower(?) and is_company=?",
				inviteCode.trim(), isCompany);
		if (user != null) {
			return true;
		}
		return false;
	}

	/**
	 * 判断一个邀请码是否已经存在，存在则返回true，不存在返回false，只判断是否为企业邀请码是否存在
	 * 
	 * @return
	 * @author zhiliang.lan
	 * @createDate 2017年6月21日16:54:54
	 * @param isCompany
	 *            是否企业参数
	 */
	public boolean isCompanyInviteCodeExist(String inviteCode) {

		t_user user = userDao.findByColumn(
				" lower(my_generate_code)=lower(?) ", inviteCode.trim());
		if (user != null) {
			return true;
		}
		return false;
	}

	/**
	 * 根据邀请码查询到user
	 * 
	 * @return
	 * @author zhiliang.lan
	 * @createDate 2017年5月23日
	 */
	public t_user findUserByInviteCode(String inviteCode) {

		return userDao.findUserByInviteCode(inviteCode);
	}

	/**
	 * 根据邀请码查询到企业的user
	 * 
	 * @return
	 * @author zhiliang.lan
	 * @createDate 2017年6月21日20:28:41
	 */
	public t_user findCompanyUserByInviteCode(String inviteCode, int isCompany) {

		return userDao.findCompanyUserByInviteCode(inviteCode, isCompany);
	}

	/**
	 * 根据邮箱号查找对应的用户信息
	 * 
	 * @param email
	 *            邮箱号
	 * @return
	 */
	public t_user EmailProving(String email) {
		t_user user = this.userDao.findByColumn("email=?", email.trim());
		return user;
	}

	/***
	 * 根据手机号查找对应的用户信息
	 * 
	 * @param mobile
	 *            手机号
	 * @return
	 */
	public t_user MobileProving(String mobile ,int is_company) {
		t_user user = userDao.findByColumn("mobile=? AND is_company = ?", mobile.trim(),is_company);
		return user;
	}

	/***
	 * 根据企业简称查找信息
	 * 
	 * @param name
	 * @return
	 */
	public boolean checkShortName(String company_short_name) {
		t_user user = this.userDao.findByColumn("company_short_name=?",
				company_short_name.trim());
		if (user != null) {
			return true;
		}
		return false;
	}

	/***
	 * 修改用户密码验证手机号
	 * 
	 * @param mobile
	 *            手机号
	 * @param userId
	 *            当前用户ID
	 * @return
	 */
	public boolean updatePasswordIsMobileExists(String mobile, long userId) {
		t_user user = this.userDao.findByColumn("mobile=? and id=?",
				mobile.trim(), userId);
		if (user != null) {
			return true;
		}
		return false;
	}

	/***
	 * 递归查找邀请码是否存在
	 * 
	 * @param code类型
	 *            0个人用户 1企业用户
	 * @return 2017年6月13日 binghui.zhou
	 */
	private String InviteCode() {
		String str = StrUtil.randomInviteCode();
		boolean bln = isInviteCodeExist(str);
		if (bln) {
			InviteCode();
		}
		return str;
	}

	/**
	 * 修改企业用户登入邮箱
	 * 
	 * @param id
	 * @param email
	 * @return
	 * @author binghui.zhou
	 * @createDate 2017年6月17日
	 */
	public boolean updateCompanyEmail(long id, String email) {
		int in = userDao.updateEmail(id, email);
		if (in < 0) {
			return false;
		}
		return true;
	}

	/**
	 * 根据企业id查user表的记录
	 * 
	 * @param companyInfoId
	 * @return
	 * @author zhiliang.lan
	 * @createDate 2017年6月16日
	 */
	public t_user findUserByCompanyInfoId(long companyInfoId) {

		return userDao.findUserByCompanyInfoId(companyInfoId);
	}

	/**
	 * 更新user信息，根据对象更新
	 * 
	 * @param user
	 * @return
	 * @author zhiliang.lan
	 * @createDate 2017年6月17日
	 */
	public ResultInfo updateUser(t_user user) {
		ResultInfo result = new ResultInfo();
		t_user user2 = findByID(user.id);
		user2.vip_code = user.vip_code;
		user2.email = user.email;
		user2.company_full_name = user.company_full_name;
		user2.company_short_name = user.company_short_name;
		user2.mobile = user.mobile;
		user2.password = user.password;
		user2.last_login_ip = user.last_login_ip;
		boolean isFlag = userDao.save(user2);
		if (!isFlag) {
			result.code = -1;
			result.msg = "更新个人信息失败";

			return result;
		}
		result.code = 1;
		result.msg = "更新个人信息成功";

		return result;
	}

	/**
	 * 忘记密码验证码手机号码
	 * 
	 * @param mobile
	 *            手机号码
	 * @param full_name
	 *            企业全称
	 * @return
	 * @author binghui.zhou
	 * @createDate 2017年6月20日
	 */
	public boolean companyIsMobileExists(String mobile, String full_name) {
		t_user user = userDao.findByColumn(
				"mobile=? and lower(company_full_name)=lower(?)", mobile,
				full_name);
		if (user != null) {
			return true;
		}
		return false;
	}

	/**
	 * 企业忘记密码验证邮箱
	 * 
	 * @param email
	 * @param full_name
	 * @return
	 * @author binghui.zhou
	 * @createDate 2017年6月20日
	 */
	public boolean companyIsEmail(String email, String full_name) {
		t_user user = userDao.findByColumn(
				"email=? and lower(company_full_name)=lower(?)", email,
				full_name);
		if (user != null) {
			return true;
		}
		return false;
	}

	/**
	 * 账户设置修改经办人邮箱跟手机号码，更新到user表中
	 * 
	 * @param id
	 * @param agent_mobile
	 *            手机号
	 * @param agent_email
	 *            邮箱
	 * @return
	 * @author binghui.zhou
	 * @createDate 2017年6月21日
	 */
	public ResultInfo updateCompanyInfo(Long id, String agent_mobile,
			String agent_email) {
		int in = userDao.updateCompanyInfo(id, agent_mobile, agent_email);
		ResultInfo result = new ResultInfo();
		if (in < 0) {
			result.code = -1;
			result.msg = "更新用户信息失败";
			return result;
		}
		result.code = 1;
		result.msg = "更新用户信息成功";
		return result;
	}

	/**
	 * 把副表涉及到登录的信息更新到登录表
	 * 
	 * @param companyInfoSide
	 * @param user
	 * @return
	 * @author zhiliang.lan
	 * @createDate 2017年6月22日
	 */
	public ResultInfo updateSideToUser(t_company_info_side companyInfoSide,
			t_user user) {

		ResultInfo result = new ResultInfo();
		int is_pledge_management = user.is_pledge_management;
		// 更新相关字段信息
		user = findByID(user.id);
		user.mobile = companyInfoSide.agent_mobile;
		user.email = companyInfoSide.agent_email;
		user.is_pledge_management = is_pledge_management;
		// 保存
		boolean isFlag = userDao.save(user);
		if (!isFlag) {
			result.code = -1;
			result.msg = "更新信息失败";
			return result;
		}
		result.code = 1;
		result.msg = "更新信息成功";

		return result;
	}

	/**
	 * 修改手机号码检验手机号码是否存在
	 * 
	 * @param mobile
	 * @param user_id
	 * @return
	 * @author zhiliang.lan
	 * @param is_company 
	 * @createDate 2017年6月27日
	 */
	public boolean isMobileExistsExceptSelf(String mobile, long user_id, int is_company) {
		t_user user = userDao.isMobileExistsExceptSelf(mobile, user_id,is_company);
		if (user != null) {
			return true;
		}

		return false;
	}

	/**
	 * 查股东，若自己是股东去股东表查询已绑定的企业
	 * 
	 * @param name
	 * @param mobile
	 * @param email
	 * @return
	 * @author zhiliang.lan
	 * @createDate 2017年6月27日
	 */
	public List<Map<String, Object>> findSholderCompanyList(long userId) {

		return userDao.findSholderCompanyList(userId);
	}

	/**
	 * 查股东，若自己是股东去股东表查询已绑定的企业 -app
	 * 
	 * @param name
	 * @param mobile
	 * @param email
	 * @return
	 * @author zhiliang.lan
	 * @createDate 2017年8月7日
	 */
	public List<Map<String, Object>> findSholderCompanyListApp(long userId) {

		return userDao.findSholderCompanyListApp(userId);
	}

	/**
	 * 修改经办人邮箱验证唯一性
	 * 
	 * @param agent_email
	 * @param userId
	 * @return
	 * @author binghui.zhou
	 * @createDate 2017年6月28日
	 */
	public boolean isEmailExistsExceptSelf(String agent_email, long userId) {
		t_user user = userDao.isEmailExistsExceptSelf(agent_email, userId);
		if (user != null) {
			return true;
		}

		return false;
	}

	/**
	 * 查询未审核基本资料的企业数量
	 * 
	 * @return
	 * @author zhiliang.lan
	 * @createDate 2017年7月17日
	 */
	public int countBasicInfoNotAudit() {

		return userDao.countBasicInfoNotAudit();
	}

	/**
	 * 查询未审核评估资料的企业数量
	 * 
	 * @return
	 * @author zhiliang.lan
	 * @createDate 2017年7月17日
	 */
	public int countAuditInfoNotAudit() {

		return userDao.countAuditInfoNotAudit();
	}

	/**
	 * 用户自动投标开关控制
	 * 
	 * @param userId
	 * @param user
	 * @return
	 * @author binghui.zhou
	 * @createDate 2017年7月18日
	 */
	public ResultInfo updateBidSwitch(long userId, t_user user) {
		ResultInfo result = new ResultInfo();
		if (!user.bid_switch) {
			user.bid_switch = true;
		} else {
			user.bid_switch = false;
		}
		if (!userDao.save(user)) {
			result.code = -1;
			result.msg = "自动投标状态锁定失败";
			return result;
		}
		result.code = 1;
		result.msg = "自动投标状态锁定成功";
		return result;
	}

	/**
	 * 查询推广用户列表
	 * 
	 * @return
	 * @author binghui.zhou
	 * @param pageSize
	 * @param currPage
	 * @param fullName
	 *            推广企业
	 * @param city_id1
	 *            被推广的市
	 * @param province_id1
	 *            被推广省
	 * @param city_id
	 *            推广市
	 * @param province_id
	 *            推广
	 * @createDate 2017年7月18日
	 */
	public PageBean<Map<String, Object>> cpsUserStatistice(int currPage,
			int pageSize, String fullName, int province_id, int city_id,
			int province_id1, int city_id1) {

		return userDao.cpsUserStatistice(currPage, pageSize, fullName,
				province_id, city_id, province_id1, city_id1);
	}

	/**
	 * 添加或修改一个实体到数据库中
	 * 
	 * @param t
	 *            实体
	 * 
	 * 
	 * @author DaiZhengmiao
	 * @createDate 2015年12月3日
	 */
	public synchronized boolean save(t_user user) {
		return basedao.save(user);
	}

	/**
	 * 后台- 注册信息汇总-报表
	 * 
	 * @param currPage
	 * @param pageSize
	 * @param exports
	 * @param userName
	 * @param userMobile
	 * @param userEmail
	 * @param checkin_time
	 * @param to_checkin_time
	 * @return
	 * @author xiaojun
	 * @version 2017-10-19
	 */
	public PageBean<UserRegistration> pageofRegistration(int currPage,
			int pageSize, Integer exports, String userName, String userMobile,
			String userEmail, String checkin_time, String to_checkin_time,
			int is_company) {
		return userDao.pageofRegistration(currPage, pageSize, exports,
				userName, userMobile, userEmail, checkin_time, to_checkin_time,
				is_company);

	}

	/**
	 * 充值成功后，进行更新用户资产信息
	 * 
	 * @param userAssets
	 *            原用户资产信息
	 * @param rechargeAmt
	 *            充值金额
	 * @return
	 * @author LiangQiongfeng
	 * @version 2018-1-17
	 */
	public boolean updateByRecharge(t_user_fund userAssets, double rechargeAmt) {
		return userDao.updateByRecharge(userAssets, rechargeAmt);
	}

	/**
	 * 根据用户名，邮箱，手机号，企业简称，企业全称查询用户是否存在
	 * 
	 * @param mobile
	 *            用户名，邮箱，手机号，企业简称，企业全称
	 * @return
	 * @author LiangQiongfeng
	 * @version 2018-1-23
	 */
	public boolean findByField(String mobile) {
		// TODO Auto-generated method stub
		return userDao.findByField(mobile);
	}

	/**
	 * 更新用户的签署方式
	 * 
	 * @param id
	 *            用户id
	 * @param dirStatus
	 *            用户更新的签署状态
	 * @param srcStatus
	 *            用户原签署状态
	 * @return
	 * @author fanghanyong
	 * @version 2018-1-23
	 */
	public boolean updateInfoAssPlegMent(long id, int srcStatus, int dirStatus) {
		return userDao.updateInfoAssPlegMent(id, srcStatus, dirStatus);
	}

	/**
	 * 通过用户id查找签署方式
	 * 
	 * @param id
	 *            用户id
	 * @return
	 * @author fanghanyong
	 * @version 2018-1-23
	 */
	public t_user findInfoAssPlegMent(long id) {
		return userDao.findByColumn(" id = ?", id);
	}
	/**
	 * 申请注销
	 *
	 * @param user_id
	 * @return
	 * @author xiaojun
	 *@version 2018-2-23
	 */
	public boolean updateUserStatus(long user_id){
		t_user user = findByID(user_id);
		user.status = UserStatus.APPLY_LOGOUT.code;
		user.apply_logout_time = new Date();
		return save(user);
	}
	/**
	 * 注销审核
	 *
	 * @param user_id
	 * @return
	 * @author xiaojun
	 *@version 2018-2-23
	 */
	public boolean auditUserStatus(long user_id,long supervisorId,int status){
		t_user user = findByID(user_id);
		user.status = status;
		// 管理员操作记录
		Map<String, String> map = new HashMap<String, String>();
		map.put("user_name", user.company_full_name== null ? user.name : user.company_full_name);
		if(status>0){
			user.logout_time = new Date();
			supervisorService.addSupervisorEvent(supervisorId,Event.LOGOUT_AUDIT, map);
			removeCurrUser(user.sessionId,user_id);
		}else{
			supervisorService.addSupervisorEvent(supervisorId,Event.LOGOUT_CANCEL, map);
		}
		
		

		return save(user);
	}
	
	/**
	 * 企业审核的查询列表 service
	 * 
	 * @param currPage
	 * @param pageSize
	 * @param userName
	 * @return
	 * @author zhiliang.lan
	 * @param orderValue 
	 * @param companyTypeId
	 * @createDate 2017年4月21日
	 */
	public PageBean<t_user> pageOfLogOutAudit(int showType,int currPage, int pageSize, String userName, int isCompany,int exports, int orderValue) {

		return userDao.pageOfLogOutAudit(showType, currPage, pageSize,userName, isCompany, exports,orderValue);
	}
	/**
	 * 修改邮箱号审核
	 * @param showType 
	 * @param currPage 
	 * @param pageSize
	 * @param userName 用户名
	 * @param companyTypeId 类型id
	 * @param exports
	 * @return
	 * @author liangqiongfeng
	 *@version 2018-2-22 
	 */
	public PageBean<ShowCompanyInfo> pageOfAuditEmail(int orderValue,int showType,
			int currPage, int pageSize, String userName, Long companyTypeId,
			int exports) {

		return userDao.pageOfAuditEmail(orderValue,showType, currPage, pageSize,
				userName, companyTypeId, exports);
	}
	
	/**
	 * 添加用户事件
	 *
	 * @param user_id 操作用户的id
	 * @param userEvent 用户事件枚举
	 * @param userEventParam 用户事件枚举中的描述参数
	 * @return
	 *
	 * @author Liangqiongfeng
	 * @createDate 2018年02月23日
	 */
	public boolean addUserEvent(long user_id, t_event_user.Event userEvent, Map<String, String> userEventParam) {
		Request request = Request.current();
		
		String ip = request.remoteAddress.toString();
		
		t_event_user event_user = new t_event_user();
		event_user.user_id = user_id;
		event_user.ip = ip;
		event_user.setDescription(userEvent, userEventParam);
		
		return userEventDao.save(event_user);
	}

	/**
	 * 分页展示会员操作信息
	 *
	 * @param showType 1--个人会员；2--企业会员
	 * @param orderValue 0--升序；1--降序
	 * @param name 输入会员名称搜索
	 * @param mobile 输入会员手机号码搜索
	 * @param exports 导出
	 * @param currPage
	 * @param pageSize
	 * @return
	 * @author liangqiongfeng
	 *@version 2018-2-24
	 */
	public PageBean<UserEventLog> pageOfUserEvent(int showType,int orderValue,String name,String mobile,
			int exports,int currPage,int pageSize) {
		
		return userEventDao.pageOfUserEvent(showType,orderValue, name,mobile, exports, currPage, pageSize);
	}

	/**
	 *	查看操作记录详情
	 * @param event_id t_event_user的id
	 * @return
	 * @author LiangQiongfeng
	 *@version 2018-2-26 
	 */
	public UserEventLog findUserEventLogById(long event_id) {
		
		return userEventDao.findUserEventLogById(event_id);
	}

	/**
	 *	根据id更改用户签署合同授权
	 * @param id
	 * @param is_accredit
	 * @return
	 * @author Liangqiongfeng
	 *@version 2018-3-6 
	 */
	public boolean updateById(Long id, int is_accredit) {
		
		return userDao.updateById(id,is_accredit);
	}

	/**
	 *	修改经办人信息申请审核
	 * @param orderValue 排序
	 * @param showType 按照何种条件排序
	 * @param currPage
	 * @param pageSize
	 * @param userName 用户名搜索
	 * @param companyTypeId 企业类型分
	 * @param exports 导出
	 * @return
	 * @author Liangqiongfeng
	 *@version 2018-3-13 
	 */
	public PageBean<ShowCompanyInfo> pageOfAuditAgent(int orderValue,
			int showType, int currPage, int pageSize, String userName,
			Long companyTypeId, int exports) {
		return userDao.pageOfAuditAgent(orderValue,showType, currPage, pageSize,
				userName, companyTypeId, exports);
	}

	/**
	 *	更改登陆手机号码
	 * @param user_id
	 * @param agent_mobile
	 * @return
	 * @author Liangqiongfeng
	 *@version 2018-3-13 
	 */
	public boolean updateAgentForUser(long user_id, String agent_mobile) {
		return userDao.updateAgentForUser(user_id,agent_mobile);
	}

	/**
	 *	个人实名认证
	 * @param showType
	 * @param currPage
	 * @param pageSize
	 * @param orderType
	 * @param orderValue
	 * @param exports
	 * @param userName
	 * @param userMobile
	 * @param userEmail
	 * @return
	 * @author Liangqiongfeng
	 *@version 2018-3-15 
	 */
	public PageBean<ShowUserInfo> pageOfRealName(int showType, int currPage,
			int pageSize, int orderType, int orderValue, int exports,
			String userName, String userMobile, String userEmail) {
		return userDao.pageOfRealName(showType, currPage, pageSize, orderType,
				orderValue, exports, userName, userMobile, userEmail);
	}

	/**
	 *
	 * @param userId
	 * @param mobile
	 * @param i
	 * @return
	 * @author xiaojun
	 *@version 2018-3-29 
	 */
	public ResultInfo updateUserMobileByUserId(long userId, String mobile, int is_company) {
		ResultInfo result = new ResultInfo();

		/* 判断手机号码是否存在 */
		if (isMobileExistsExceptSelf(mobile, userId,is_company)) {
			result.code = -1;
			result.msg = "手机号码已存在";
			return result;
		}
		/* 修改用户信息表中的手机号字段 */
		result = userInfoService.updateUserMobile(userId, mobile);
		if (result.code < 0) {

			return result;
		}
		/* 修改用户表中的手机号字段 */
		int i = userDao.updateUserMobile(userId, mobile);
		if (i < 0) {
			result.code = -1;
			result.msg = "手机号码修改失败";
			return result;
		}

		t_user user = userDao.findByID(userId);

		/** 手机号绑定更改 发送通知 */
		Map<String, Object> param = new HashMap<String, Object>();
		param.put("user_name", user.is_company == 0 ? user.name
				: user.company_full_name);
		noticeService.sendSysNotice(userId, NoticeScene.BIND_MOBILE_SUCC, param);

		result.code = 1;
		result.msg = "手机号码修改成功";
		/* 刷新缓存用户信息 */
		flushUserCache(userId);

		return result;
	}

	/**
	 * 修改登录
	 * @param id 当前用户id
	 * @param anxinsign_url
	 * @return
	 * @author xiaojun
	 *@version 2018-4-27 
	 */
	public boolean updateUrlById(Long id, String anxinsign_url) {
		
		return userDao.updateUrlById(id,anxinsign_url);
	}

	/**
	 *	根据用户名去查询对应的个人用户信息
	 * @param mobile
	 * @param is_company
	 * @return
	 * @author hufei
	 *@version 2018年5月29日 
	 */
	public t_user NameProving(String mobile, int is_company) {
		t_user user = userDao.findByColumn("name=? AND is_company = ?", mobile.trim(),is_company);
		return user;
	}

	
}
